package ml.kupin.content.service.impl;

import ml.kupin.content.service.ContentCategoryService;
import ml.kupin.common.constant.KuPinConstant;
import ml.kupin.mapper.TbContentCategoryMapper;
import ml.kupin.pojo.TbContentCategory;
import ml.kupin.pojo.TbContentCategoryExample;
import ml.kupin.common.utils.KuPinResult;
import ml.kupin.common.vo.EasyUITreeNode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;


/**
 * Created by 小柯(Allen Kerr) on 17.4.26 19:19.
 */
@Service
public class ContentCategoryServiceImpl implements ContentCategoryService {

    @Autowired
    private TbContentCategoryMapper contentCatMapper;

    @Override
    public List<EasyUITreeNode> getContentCategories(long parentId) {
        //依据 parentId 查询 ContentCategory的集合
        TbContentCategoryExample contentCatExample = new TbContentCategoryExample();
        TbContentCategoryExample.Criteria criteria = contentCatExample.createCriteria();

        //查询条件设置
        /**
         * criteria.andStatusEqualTo(KuPinConstant.ContentCategory_Normal);
         * 排除已删除的分类
         */
        criteria.andParentIdEqualTo(parentId);
        criteria.andStatusEqualTo(KuPinConstant.ContentCategory_Normal);

        //执行查询
        List<TbContentCategory> contentCategories = contentCatMapper.selectByExample(contentCatExample);

        //转换成 EasyUITreeNode的集合
        List<EasyUITreeNode> easyUITreeNodeList = new ArrayList<>();
        for (TbContentCategory contentCategory : contentCategories) {
            EasyUITreeNode easyUITreeNode = new EasyUITreeNode();
            easyUITreeNode.setId(contentCategory.getId());
            easyUITreeNode.setText(contentCategory.getName());
            easyUITreeNode.setState(contentCategory.getIsParent() ? "closed" : "open");
            easyUITreeNodeList.add(easyUITreeNode);
        }

        //返回结果
        return easyUITreeNodeList;
    }

    /**
     * 增加内容分类
     *
     * @param parentId
     * @param text
     * @return
     * @throws Exception
     */
    @Override
    public KuPinResult addContentCategory(long parentId, String text) throws Exception {
        TbContentCategory contentCat = null;
        try {
            //封装数据
            contentCat = new TbContentCategory();
            /**
             * id 自增长
             * status 状态，可选值: 1(正常), 2(删除)
             * is_parent 该类目是否为父类目，1为true，0为false
             * sort_order 排列序号，表示同级类目的展现次序，如数值相等则按名称次序排列。取值范围: 大于零的整数，填1即可
             */
            contentCat.setName(text);
            contentCat.setParentId(parentId);
            Date addAndUpdateTime = new Date();
            contentCat.setCreated(addAndUpdateTime);
            contentCat.setUpdated(addAndUpdateTime);
            contentCat.setIsParent(false);
            contentCat.setStatus(KuPinConstant.ContentCategory_Normal);
            contentCat.setSortOrder(1);

            //执行插入操作
            //插入数据之后，会自动返回自增长的主键 id 的值到 contentCat 中
            long id = contentCatMapper.insertSelective(contentCat);

            //判断父节点的isparent属性，如果不是true改为true。
            TbContentCategory parentContentCat = contentCatMapper.selectByPrimaryKey(parentId);
            if (!parentContentCat.getIsParent()) {
                parentContentCat.setIsParent(true);
                contentCatMapper.updateByPrimaryKeySelective(parentContentCat);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        //返回结果KuPinResult，必须包含新增的 ContentCategory，
        //页面需要用到它的Id
        return KuPinResult.ok(contentCat);
    }

    /**
     * 更新内容分类
     *
     * @param id
     * @param name
     */
    @Override
    public KuPinResult updateContentCategory(long id, String name) {
        try {
            //封装数据
            TbContentCategory contentCategory = new TbContentCategory(id, name, new Date());
            //更新
            contentCatMapper.updateByPrimaryKeySelective(contentCategory);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        //更新成功，返回结果
        return KuPinResult.ok();
    }

    /**
     * 删除内容分类
     * ————父节点不能删除！
     *
     * @param id
     * @return
     */
    @Override
    public KuPinResult deleteContentCategory(long id) throws Exception {
        try {
            //查询id对应的节点是否为父节点，如果是，不能删
            TbContentCategory contentCategory = contentCatMapper.selectByPrimaryKey(id);
            if (contentCategory.getIsParent())
                return KuPinResult.notOk("父节点不能删除！必须先移除它所有的子节点！");

            //删除叶子节点
            contentCategory.setStatus(KuPinConstant.ContentCategory_Deleted);
            contentCategory.setUpdated(new Date());
            contentCatMapper.updateByPrimaryKeySelective(contentCategory);

            /**
             * 重点：
             * 判断该叶子节点的父节点是否还有子节点，如果没有，将其改为叶子节点
             */
            //1. parentId --> 按parentContentCat的id作为parentId查正常状态的叶子节点
            TbContentCategoryExample contentCatExample = new TbContentCategoryExample();
            TbContentCategoryExample.Criteria criteria = contentCatExample.createCriteria();
            criteria.andParentIdEqualTo(contentCategory.getParentId());
            criteria.andStatusEqualTo(KuPinConstant.ContentCategory_Normal);
            List<TbContentCategory> contentCategories = contentCatMapper.selectByExample(contentCatExample);
            //2. 没有子节点，改父节点为叶子节点
            if (contentCategories.size() == 0) {
                TbContentCategory parentContentCat = new TbContentCategory();
                parentContentCat.setId(contentCategory.getParentId());
                parentContentCat.setIsParent(false);
                parentContentCat.setUpdated(new Date());
                //更新父节点
                contentCatMapper.updateByPrimaryKeySelective(parentContentCat);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return KuPinResult.ok();
    }


}
